/**
 * 文件解析器工厂类
 * 实现工厂模式，用于创建不同类型的文件解析器
 */
/* eslint-disable no-unused-vars */
import * as XLSX from 'xlsx';
import logger from './Logger';

// 文件解析器接口
class FileParser {
  constructor() {
    if (this.constructor === FileParser) {
      throw new Error('抽象类不能被实例化');
    }
  }

  parse(file) {
    throw new Error('子类必须实现parse方法');
  }
}

// Excel文件解析器
class ExcelParser extends FileParser {
  /**
   * 解析Excel文件
   * @param {File} file - Excel文件对象
   * @returns {Promise<Array>} 解析后的数据数组
   */
  parse(file) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();

      reader.onload = (e) => {
        try {
          const data = new Uint8Array(e.target.result);
          const workbook = XLSX.read(data, { type: 'array' });

          // 获取第一个工作表
          const firstSheetName = workbook.SheetNames[0];
          const worksheet = workbook.Sheets[firstSheetName];

          // 将工作表转换为JSON
          const jsonData = XLSX.utils.sheet_to_json(worksheet);

          logger.info('Excel文件解析成功', { rows: jsonData.length });
          resolve(jsonData);
        } catch (error) {
          logger.error('Excel文件解析失败', error);
          reject(error);
        }
      };

      reader.onerror = (error) => {
        logger.error('读取Excel文件失败', error);
        reject(error);
      };

      reader.readAsArrayBuffer(file);
    });
  }
}

// CSV文件解析器
class CSVParser extends FileParser {
  /**
   * 解析CSV文件
   * @param {File} file - CSV文件对象
   * @returns {Promise<Array>} 解析后的数据数组
   */
  parse(file) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();

      reader.onload = (e) => {
        try {
          const csvString = e.target.result;
          const lines = csvString.split('\n');
          const headers = lines[0].split(',').map(header => header.trim());

          const jsonData = [];

          for (let i = 1; i < lines.length; i++) {
            if (lines[i].trim() === '') continue;

            const values = lines[i].split(',').map(value => value.trim());
            const entry = {};

            for (let j = 0; j < headers.length; j++) {
              entry[headers[j]] = values[j];
            }

            jsonData.push(entry);
          }

          logger.info('CSV文件解析成功', { rows: jsonData.length });
          resolve(jsonData);
        } catch (error) {
          logger.error('CSV文件解析失败', error);
          reject(error);
        }
      };

      reader.onerror = (error) => {
        logger.error('读取CSV文件失败', error);
        reject(error);
      };

      reader.readAsText(file);
    });
  }
}

// 文件解析器工厂
class FileParserFactory {
  /**
   * 创建文件解析器
   * @param {string} fileType - 文件类型
   * @returns {FileParser} 文件解析器实例
   */
  static createParser(fileType) {
    switch (fileType.toLowerCase()) {
      case 'xlsx':
      case 'xls':
        return new ExcelParser();
      case 'csv':
        return new CSVParser();
      case 'doc':
      case 'docx':
        logger.info(`检测到Word文档: ${fileType}，将使用服务器端解析`);
        return {
          parse: () => Promise.resolve([]) // Word文档在服务器端解析，前端仅作占位
        };
      default:
        logger.error(`不支持的文件类型: ${fileType}，仅支持Excel、Word和CSV格式`);
        throw new Error(`不支持的文件类型: ${fileType}，仅支持Excel、Word和CSV格式`);
    }
  }

  /**
   * 根据文件扩展名创建解析器
   * @param {File} fileObj - 文件对象
   * @returns {FileParser} 文件解析器实例
   */
  static createParserFromFile(fileObj) {
    const fileName = fileObj.name;
    const fileExtension = fileName.split('.').pop();
    return this.createParser(fileExtension);
  }
}

export default FileParserFactory;
